package com.zw.mes.module.prodtaskmanager.service;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.zw.mes.common.JsonResult;
import com.zw.mes.entity.sys.User;
import com.zw.mes.module.prodtaskmanager.entity.*;
import com.zw.mes.module.prodtaskmanager.mapper.ProdOrdMapper;
import com.zw.mes.module.prodtaskmanager.mapper.ProdTaskMapper;
import com.zw.mes.module.prodtaskmanager.model.*;
import com.zw.mes.module.system.service.LogService;
import com.zw.mes.util.FileUtils;
import com.zw.mes.util.ShiroUtils;
import lombok.extern.log4j.Log4j2;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletResponse;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author 徐一贺
 * @className ProdTaskService
 * @description 生产任务排产业务逻辑层
 * @date 2021/1/11 16:01
 * @versron ver 1.0
 */
@Log4j2
@Service
public class ProdTaskService {
    @Value("${user.upload.path}")
    private String uploadPath;

    private ProdTaskMapper prodTaskMapper;

    @Autowired
    public void setProdTaskMapper(ProdTaskMapper prodTaskMapper) {
        this.prodTaskMapper = prodTaskMapper;
    }

    private ProdOrdMapper prodOrdMapper;

    @Autowired
    private void setProdOrdMapper(ProdOrdMapper prodOrdMapper) {
        this.prodOrdMapper = prodOrdMapper;
    }

    private LogService logService;

    @Autowired
    private void setLogService(LogService logService) {
        this.logService = logService;
    }

    /**
     * schedulingList 获取排产任务池页的表格数据
     *
     * @param param 检索条件
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdPlaModel>
     * @author 徐一贺
     * @date 2021/1/15 12:45
     */
    public List<ProdPlaModel> schedulingList(ProdPlaModel param) {
        return prodTaskMapper.findProdPlanModelByParam(param);
    }

    /**
     * commonList 获取普通任务池页的表格数据
     *
     * @param param 检索条件
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdPlaModel>
     * @author 徐一贺
     * @date 2021/1/29 16:36
     */
    public List<ProdPlaModel> commonList(ProdPlaModel param) {
        return prodTaskMapper.findProdPlanModelByParamAndCommon(param);
    }

    /**
     * getProdOrdByPrimaryKey 根据主键获取生产令信息
     *
     * @param prodId
     * @return com.zw.mes.module.prodtaskmanager.entity.ProdOrd
     * @author 徐一贺
     * @date 2021/1/15 13:33
     */
    public ProdOrdModel getProdOrdByPrimaryKey(Integer prodId) {
        return prodOrdMapper.getProdOrdModelByPrimaryKey(prodId);
    }

    /**
     * findTotalDispatchPlanItem 获取总调计划列表项
     *
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.BaseData>
     * @author 徐一贺
     * @date 2021/1/15 14:44
     */
    public List<BaseData> findTotalDispatchPlanItem() {
        return prodTaskMapper.findTotalDispatchPlanItem();
    }

    /**
     * 保存设备类生产令排产计划
     *
     * @param prodNo         生产令
     * @param prodPlaDetList 排产计划集合
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/15 16:37
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveSchedulingPla(String prodNo, List<ProdPlaDetModel> prodPlaDetList) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdOrd order = prodOrdMapper.getProdOrdByProdNo(prodNo);
            if (order == null) {
                jsonResult.setType(JsonResult.ResultType.ERROR);
                jsonResult.setMsg("该生产令已被删除，请刷新排产任务池页面！");
                return jsonResult;
            }
            ProdPlaModel planModel = prodTaskMapper.getProdPlaByProdNo(prodNo);
            // 如果是空则添加主调计划
            if (planModel == null) {
                ProdPla plan = new ProdPla();
                plan.setPropProdNo(order.getProdNo());
                plan.setPropProCod(order.getProdProCod());
                plan.setPropProdNum(order.getProdNum());
                plan.setPropCreDat(new Date());
                plan.setPropCreUid(ShiroUtils.getUserId());
                plan.setPropSta(1);
                plan.setPropIsDel((byte) 0);
                plan.setPropRem(order.getProdRem());
                plan.setPropIsDel((byte) 0);
                prodTaskMapper.insertProdPla(plan);
                for (ProdPlaDet prodPlaDet : prodPlaDetList) {
                    prodPlaDet.setPrpdPropId(plan.getPropId());
                    prodPlaDet.setPrpdIsNee((byte) 1);
                    prodPlaDet.setPrpdSta(1);
                    prodPlaDet.setPrpdIsReq(
                            Byte.valueOf(prodTaskMapper.getTotalPlanIsNotNull(prodPlaDet.getPrpdCod())));
                    prodTaskMapper.insertProdPlaDet(prodPlaDet);
                }
                // 获取生产任务模板数据
                List<BaseData> prodTaskTemplateData = prodTaskMapper.findProdTaskTemplateData();
                for (BaseData prodTaskTemplate : prodTaskTemplateData) {
                    ProdTas task = new ProdTas();
                    task.setProtPropId(plan.getPropId());
                    task.setProtNam(prodTaskTemplate.getBadaNam());
                    task.setProtCod(prodTaskTemplate.getBadaCod());
                    task.setProtTyp(prodTaskTemplate.getBadaVal());
                    task.setProtSta(1);
                    prodTaskMapper.insertProdTask(task);
                }
                // 获取生产反馈模板数据
                List<BaseData> prodReturnInfoTemplateData = prodTaskMapper.findProdReturnInfoTemplateData();
                for (BaseData prodReturnInfoTemplate : prodReturnInfoTemplateData) {
                    ProdPlaRetModel retInfo = new ProdPlaRetModel();
                    retInfo.setPrprPropId(plan.getPropId());
                    retInfo.setPrprNam(prodReturnInfoTemplate.getBadaNam());
                    retInfo.setPrprCod(prodReturnInfoTemplate.getBadaCod());
                    retInfo.setPrprOrdNo(prodReturnInfoTemplate.getBadaOrdNo());
                    prodTaskMapper.insertProdPlanRetInfo(retInfo);
                }
            }
            // 如果是非空则更新主调计划
            else {
                List<ProdPlaDet> existProdPlaDetList =
                        prodTaskMapper.findProdPlanDetailListByProdPlanId(planModel.getPropId());
                // 如果是变更则记录变更记录
                if (planModel.getPropSta() == 5) {
                    // 如果是重点项目设置成未提交
                    if (order.getProdIsKey() == 1) {
                        planModel.setPropSta(1);
                        planModel.setPropIsCha((byte) 1);
                        prodTaskMapper.updateProdPla(planModel);
                        logService.saveLog(
                                "排产任务池-->总调计划变更", "变更计划号为：【" + planModel.getPropProdNo() + "】的总调计划。");
                    }

                    for (int i = 0; i < prodPlaDetList.size(); i++) {
                        ProdPlaDet newProdPlaDet = prodPlaDetList.get(i);
                        ProdPlaDet toDataBaseProdPlaDet =
                                convertInsertProdPlanDetail(existProdPlaDetList, newProdPlaDet);
                        // 如果数据库中有则更新
                        Date currentDate = new Date();
                        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                        if (toDataBaseProdPlaDet != null) {
                            for (int j = 0; j < existProdPlaDetList.size(); j++) {
                                if (newProdPlaDet.getPrpdCod().equals(existProdPlaDetList.get(j).getPrpdCod())) {

                                    String befStaDat =
                                            existProdPlaDetList.get(j).getPrpdPlaStaDat() == null
                                                    ? ""
                                                    : dateFormat.format(existProdPlaDetList.get(j).getPrpdPlaStaDat());
                                    String befEndDat =
                                            existProdPlaDetList.get(j).getPrpdPlaEndDat() == null
                                                    ? ""
                                                    : dateFormat.format(existProdPlaDetList.get(j).getPrpdPlaEndDat());
                                    String aftStaDat =
                                            newProdPlaDet.getPrpdPlaStaDat() == null
                                                    ? ""
                                                    : dateFormat.format(newProdPlaDet.getPrpdPlaStaDat());
                                    String aftEndDat =
                                            newProdPlaDet.getPrpdPlaEndDat() == null
                                                    ? ""
                                                    : dateFormat.format(newProdPlaDet.getPrpdPlaEndDat());
                                    if (!befStaDat.equals(aftStaDat)) {
                                        ProdPlaCha staDatChangeRecord = new ProdPlaCha();
                                        staDatChangeRecord.setPrpcPropId(planModel.getPropId());
                                        staDatChangeRecord.setPrpcNam(existProdPlaDetList.get(j).getPrpdNam());
                                        staDatChangeRecord.setPrpcCod(existProdPlaDetList.get(j).getPrpdCod());
                                        staDatChangeRecord.setPrpcOrdNo(existProdPlaDetList.get(j).getPrpdOrdNo());
                                        staDatChangeRecord.setPrpcFieldType(1);
                                        staDatChangeRecord.setPrpcBef(befStaDat);
                                        staDatChangeRecord.setPrpcAft(aftStaDat);
                                        staDatChangeRecord.setPrpcMode(1);
                                        staDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                                        staDatChangeRecord.setPrpcChaDat(currentDate);
                                        staDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                                        staDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                                        staDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                                        staDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                                        prodTaskMapper.insertProdPlaCha(staDatChangeRecord);
                                    }
                                    if (!befEndDat.equals(aftEndDat)) {
                                        ProdPlaCha endDatChangeRecord = new ProdPlaCha();
                                        endDatChangeRecord.setPrpcPropId(planModel.getPropId());
                                        endDatChangeRecord.setPrpcNam(existProdPlaDetList.get(j).getPrpdNam());
                                        endDatChangeRecord.setPrpcCod(existProdPlaDetList.get(j).getPrpdCod());
                                        endDatChangeRecord.setPrpcOrdNo(existProdPlaDetList.get(j).getPrpdOrdNo());
                                        endDatChangeRecord.setPrpcFieldType(2);
                                        endDatChangeRecord.setPrpcBef(befEndDat);
                                        endDatChangeRecord.setPrpcAft(aftEndDat);
                                        endDatChangeRecord.setPrpcMode(1);
                                        endDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                                        endDatChangeRecord.setPrpcChaDat(currentDate);
                                        endDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                                        endDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                                        endDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                                        endDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                                        prodTaskMapper.insertProdPlaCha(endDatChangeRecord);
                                    }
                                    break;
                                }
                            }
                        }
                        // 如果数据库中无则插入
                        else {
                            String befStaDat = "";
                            String befEndDat = "";
                            String aftStaDat =
                                    newProdPlaDet.getPrpdPlaStaDat() == null
                                            ? ""
                                            : dateFormat.format(newProdPlaDet.getPrpdPlaStaDat());
                            String aftEndDat =
                                    newProdPlaDet.getPrpdPlaEndDat() == null
                                            ? ""
                                            : dateFormat.format(newProdPlaDet.getPrpdPlaEndDat());
                            ProdPlaCha staDatChangeRecord = new ProdPlaCha();
                            staDatChangeRecord.setPrpcPropId(planModel.getPropId());
                            staDatChangeRecord.setPrpcNam("");
                            staDatChangeRecord.setPrpcCod("");
                            staDatChangeRecord.setPrpcOrdNo(newProdPlaDet.getPrpdOrdNo());
                            staDatChangeRecord.setPrpcFieldType(1);
                            staDatChangeRecord.setPrpcBef(befStaDat);
                            staDatChangeRecord.setPrpcAft(aftStaDat);
                            staDatChangeRecord.setPrpcMode(2);
                            staDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                            staDatChangeRecord.setPrpcChaDat(currentDate);
                            staDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                            staDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                            staDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                            staDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                            prodTaskMapper.insertProdPlaCha(staDatChangeRecord);
                            ProdPlaCha endDatChangeRecord = new ProdPlaCha();
                            endDatChangeRecord.setPrpcPropId(planModel.getPropId());
                            endDatChangeRecord.setPrpcNam(newProdPlaDet.getPrpdNam());
                            endDatChangeRecord.setPrpcCod(newProdPlaDet.getPrpdCod());
                            endDatChangeRecord.setPrpcOrdNo(newProdPlaDet.getPrpdOrdNo());
                            endDatChangeRecord.setPrpcFieldType(2);
                            endDatChangeRecord.setPrpcBef(befEndDat);
                            endDatChangeRecord.setPrpcAft(aftEndDat);
                            endDatChangeRecord.setPrpcMode(2);
                            endDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                            endDatChangeRecord.setPrpcChaDat(currentDate);
                            endDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                            endDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                            endDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                            endDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                            prodTaskMapper.insertProdPlaCha(endDatChangeRecord);
                            break;
                        }
                    }
                    logService.saveLog("排产任务池-->总调计划编辑", "新增划号为：【" + planModel.getPropProdNo() + "】的总调计划。");
                } else {
                    logService.saveLog("排产任务池-->总调计划编辑", "修改计划号为：【" + planModel.getPropProdNo() + "】的总调计划。");
                }
                for (ProdPlaDet newProdPlaDet : prodPlaDetList) {
                    ProdPlaDet toDataBaseProdPlaDet =
                            convertInsertProdPlanDetail(existProdPlaDetList, newProdPlaDet);
                    // 如果数据库中有则更新
                    if (toDataBaseProdPlaDet != null) {
                        prodTaskMapper.updateProdPlaDet(toDataBaseProdPlaDet);
                    }
                    // 没有则添加
                    else {
                        newProdPlaDet.setPrpdPropId(planModel.getPropId());
                        newProdPlaDet.setPrpdIsNee((byte) 1);
                        newProdPlaDet.setPrpdSta(1);
                        newProdPlaDet.setPrpdIsReq(
                                Byte.valueOf(prodTaskMapper.getTotalPlanIsNotNull(newProdPlaDet.getPrpdCod())));
                        prodTaskMapper.insertProdPlaDet(newProdPlaDet);
                    }
                }
            }
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【保存设备类生产令排产异常】：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存失败！");
        }
        return jsonResult;
    }

    /**
     * @methodName: saveChangeCommonPlan
     * @description: 普通计划变更
     * @param: prodNo
     * @param: prodPlaDetList
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺
     * @date： 2021/3/25 18:31
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveChangeCommonPlan(
            String prodNo, List<ProdPlaDetModel> prodPlaDetList, Integer[] delPrpdIdArray) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdOrd order = prodOrdMapper.getProdOrdByProdNo(prodNo);
            if (order == null) {
                jsonResult.setType(JsonResult.ResultType.ERROR);
                jsonResult.setMsg("该生产令已被删除，请刷新排产任务池页面！");
                return jsonResult;
            }
            if (delPrpdIdArray != null) {
                for (Integer integer : delPrpdIdArray) {
                    ProdPlaDet prodPlaDet = prodOrdMapper.getProdPlaDetByPrimaryKey(integer);
                    prodOrdMapper.deleteProdPlaDetailByPrimary(integer);
                    logService.saveLog("普通任务池-->总调计划变更", "删除了名称为【" + prodPlaDet.getPrpdNam() + "】的计划。");
                }
            }
            ProdPlaModel planModel = prodTaskMapper.getProdPlaByProdNo(prodNo);
            // 如果是空则添加主调计划
            if (planModel == null) {
                ProdPla plan = new ProdPla();
                plan.setPropProdNo(order.getProdNo());
                plan.setPropProCod(order.getProdProCod());
                plan.setPropProdNum(order.getProdNum());
                plan.setPropCreDat(new Date());
                plan.setPropCreUid(ShiroUtils.getUserId());
                plan.setPropSta(1);
                plan.setPropIsDel((byte) 0);
                plan.setPropRem(order.getProdRem());
                plan.setPropIsDel((byte) 0);
                prodTaskMapper.insertProdPla(plan);
                for (ProdPlaDet prodPlaDet : prodPlaDetList) {
                    prodPlaDet.setPrpdPropId(plan.getPropId());
                    prodPlaDet.setPrpdIsNee((byte) 1);
                    prodPlaDet.setPrpdSta(1);
                    prodPlaDet.setPrpdIsReq(
                            Byte.valueOf(prodTaskMapper.getTotalPlanIsNotNull(prodPlaDet.getPrpdCod())));
                    prodTaskMapper.insertProdPlaDet(prodPlaDet);
                }
                // 获取生产任务模板数据
                List<BaseData> prodTaskTemplateData = prodTaskMapper.findProdTaskTemplateData();
                for (BaseData prodTaskTemplate : prodTaskTemplateData) {
                    ProdTas task = new ProdTas();
                    task.setProtPropId(plan.getPropId());
                    task.setProtNam(prodTaskTemplate.getBadaNam());
                    task.setProtCod(prodTaskTemplate.getBadaCod());
                    task.setProtTyp(prodTaskTemplate.getBadaVal());
                    task.setProtSta(1);
                    prodTaskMapper.insertProdTask(task);
                }
                // 获取生产反馈模板数据
                List<BaseData> prodReturnInfoTemplateData = prodTaskMapper.findProdReturnInfoTemplateData();
                for (BaseData prodReturnInfoTemplate : prodReturnInfoTemplateData) {
                    ProdPlaRetModel retInfo = new ProdPlaRetModel();
                    retInfo.setPrprPropId(plan.getPropId());
                    retInfo.setPrprNam(prodReturnInfoTemplate.getBadaNam());
                    retInfo.setPrprCod(prodReturnInfoTemplate.getBadaCod());
                    retInfo.setPrprOrdNo(prodReturnInfoTemplate.getBadaOrdNo());
                    prodTaskMapper.insertProdPlanRetInfo(retInfo);
                }
            }
            // 如果是非空则更新主调计划
            else {
                List<ProdPlaDet> existProdPlaDetList = prodTaskMapper.findProdPlanDetailListByProdPlanId(planModel.getPropId());
                // 如果是变更则记录变更记录
                if (planModel.getPropSta() == 5) {
                    // 如果是重点项目设置成未提交
                    if (order.getProdIsKey() == 1) {
                        planModel.setPropSta(1);
                        planModel.setPropIsCha((byte) 1);
                        prodTaskMapper.updateProdPla(planModel);
                        logService.saveLog("普通任务池-->总调计划变更", "变更计划号为：【" + planModel.getPropProdNo() + "】的总调计划。");
                    }
                    for (int i = 0; i < prodPlaDetList.size(); i++) {
                        ProdPlaDet newProdPlaDet = prodPlaDetList.get(i);
                        // 如果数据库中有则更新
                        Date currentDate = new Date();
                        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                        if (newProdPlaDet.getPrpdId() != null) {
                            for (int j = 0; j < existProdPlaDetList.size(); j++) {
                                if (newProdPlaDet.getPrpdId().intValue() == existProdPlaDetList.get(j).getPrpdId().intValue()) {
                                    String befStaDat = existProdPlaDetList.get(j).getPrpdPlaStaDat() == null ? "" : dateFormat.format(existProdPlaDetList.get(j).getPrpdPlaStaDat());
                                    String befEndDat = existProdPlaDetList.get(j).getPrpdPlaEndDat() == null ? "" : dateFormat.format(existProdPlaDetList.get(j).getPrpdPlaEndDat());
                                    String aftStaDat = newProdPlaDet.getPrpdPlaStaDat() == null ? "" : dateFormat.format(newProdPlaDet.getPrpdPlaStaDat());
                                    String aftEndDat = newProdPlaDet.getPrpdPlaEndDat() == null ? "" : dateFormat.format(newProdPlaDet.getPrpdPlaEndDat());
                                    if (!befStaDat.equals(aftStaDat)) {
                                        ProdPlaCha staDatChangeRecord = new ProdPlaCha();
                                        staDatChangeRecord.setPrpcPropId(planModel.getPropId());
                                        staDatChangeRecord.setPrpcNam(existProdPlaDetList.get(j).getPrpdNam());
                                        staDatChangeRecord.setPrpcCod(existProdPlaDetList.get(j).getPrpdCod());
                                        staDatChangeRecord.setPrpcOrdNo(existProdPlaDetList.get(j).getPrpdOrdNo());
                                        staDatChangeRecord.setPrpcFieldType(1);
                                        staDatChangeRecord.setPrpcBef(befStaDat);
                                        staDatChangeRecord.setPrpcAft(aftStaDat);
                                        staDatChangeRecord.setPrpcMode(1);
                                        staDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                                        staDatChangeRecord.setPrpcChaDat(currentDate);
                                        staDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                                        staDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                                        staDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                                        staDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                                        prodTaskMapper.insertProdPlaCha(staDatChangeRecord);
                                    }
                                    if (!befEndDat.equals(aftEndDat)) {
                                        ProdPlaCha endDatChangeRecord = new ProdPlaCha();
                                        endDatChangeRecord.setPrpcPropId(planModel.getPropId());
                                        endDatChangeRecord.setPrpcNam(existProdPlaDetList.get(j).getPrpdNam());
                                        endDatChangeRecord.setPrpcCod(existProdPlaDetList.get(j).getPrpdCod());
                                        endDatChangeRecord.setPrpcOrdNo(existProdPlaDetList.get(j).getPrpdOrdNo());
                                        endDatChangeRecord.setPrpcFieldType(2);
                                        endDatChangeRecord.setPrpcBef(befEndDat);
                                        endDatChangeRecord.setPrpcAft(aftEndDat);
                                        endDatChangeRecord.setPrpcMode(1);
                                        endDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                                        endDatChangeRecord.setPrpcChaDat(currentDate);
                                        endDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                                        endDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                                        endDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                                        endDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                                        prodTaskMapper.insertProdPlaCha(endDatChangeRecord);
                                    }
                                    break;
                                }
                            }
                        }
                        // 如果数据库中无则插入
                        else {
                            String befStaDat = "";
                            String befEndDat = "";
                            String aftStaDat = newProdPlaDet.getPrpdPlaStaDat() == null ? "" : dateFormat.format(newProdPlaDet.getPrpdPlaStaDat());
                            String aftEndDat = newProdPlaDet.getPrpdPlaEndDat() == null ? "" : dateFormat.format(newProdPlaDet.getPrpdPlaEndDat());
                            ProdPlaCha staDatChangeRecord = new ProdPlaCha();
                            staDatChangeRecord.setPrpcPropId(planModel.getPropId());
                            staDatChangeRecord.setPrpcNam("");
                            staDatChangeRecord.setPrpcCod("");
                            staDatChangeRecord.setPrpcOrdNo(newProdPlaDet.getPrpdOrdNo());
                            staDatChangeRecord.setPrpcFieldType(1);
                            staDatChangeRecord.setPrpcBef(befStaDat);
                            staDatChangeRecord.setPrpcAft(aftStaDat);
                            staDatChangeRecord.setPrpcMode(2);
                            staDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                            staDatChangeRecord.setPrpcChaDat(currentDate);
                            staDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                            staDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                            staDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                            staDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                            prodTaskMapper.insertProdPlaCha(staDatChangeRecord);
                            ProdPlaCha endDatChangeRecord = new ProdPlaCha();
                            endDatChangeRecord.setPrpcPropId(planModel.getPropId());
                            endDatChangeRecord.setPrpcNam(newProdPlaDet.getPrpdNam());
                            endDatChangeRecord.setPrpcCod(newProdPlaDet.getPrpdCod());
                            endDatChangeRecord.setPrpcOrdNo(newProdPlaDet.getPrpdOrdNo());
                            endDatChangeRecord.setPrpcFieldType(2);
                            endDatChangeRecord.setPrpcBef(befEndDat);
                            endDatChangeRecord.setPrpcAft(aftEndDat);
                            endDatChangeRecord.setPrpcMode(2);
                            endDatChangeRecord.setPrpcChaRea(newProdPlaDet.getPrpdChaRea());
                            endDatChangeRecord.setPrpcChaDat(currentDate);
                            endDatChangeRecord.setPrpcChaUsrId(ShiroUtils.getUserId());
                            endDatChangeRecord.setPrpcOs(newProdPlaDet.getPrpcOs());
                            endDatChangeRecord.setPrpcBrowser(newProdPlaDet.getPrpcBrowser());
                            endDatChangeRecord.setPrpcIp(newProdPlaDet.getPrpcIp());
                            prodTaskMapper.insertProdPlaCha(endDatChangeRecord);
                            break;
                        }
                    }
                    logService.saveLog("普通任务池-->总调计划编辑", "新增划号为：【" + planModel.getPropProdNo() + "】的总调计划。");
                } else {
                    logService.saveLog("普通任务池-->总调计划编辑", "修改计划号为：【" + planModel.getPropProdNo() + "】的总调计划。");
                }
                for (int i = 0; i < prodPlaDetList.size(); i++) {
                    ProdPlaDet newProdPlaDet = prodPlaDetList.get(i);
                    ProdPlaDet toDataBaseProdPlaDet =
                            convertInsertProdPlanDetail2(existProdPlaDetList, newProdPlaDet);
                    // 如果数据库中有则更新
                    if (toDataBaseProdPlaDet != null) {
                        prodTaskMapper.updateProdPlaDet(toDataBaseProdPlaDet);
                    }
                    // 没有则添加
                    else {
                        newProdPlaDet.setPrpdPropId(planModel.getPropId());
                        newProdPlaDet.setPrpdIsNee((byte) 1);
                        newProdPlaDet.setPrpdSta(1);
                        newProdPlaDet.setPrpdIsDel((byte) 0);
                        if (newProdPlaDet.getPrpdCod() != null) {
                            newProdPlaDet.setPrpdIsReq(Byte.valueOf(prodTaskMapper.getTotalPlanIsNotNull(newProdPlaDet.getPrpdCod())));
                        } else {
                            newProdPlaDet.setPrpdIsReq((byte) 0);
                        }
                        prodTaskMapper.insertProdPlaDet(newProdPlaDet);
                    }
                }
            }
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【保存其他类类生产令排产异常】：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存失败！");
        }
        return jsonResult;
    }

    /**
     * commonSaveSchedulingPlan 保存其他类产令排产计划
     *
     * @param prodNo         生产令
     * @param prodPlaDetList 排产计划
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/2/1 9:56
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult commonSaveSchedulingPlan(String prodNo, List<ProdPlaDetModel> prodPlaDetList, List<Integer> delPrpdIdList) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdOrd order = prodOrdMapper.getProdOrdByProdNo(prodNo);
            if (order == null) {
                jsonResult.setType(JsonResult.ResultType.ERROR);
                jsonResult.setMsg("该生产令已被删除，请刷新排产任务池页面！");
                return jsonResult;
            }
            ProdPlaModel planModel = prodTaskMapper.getProdPlaByProdNo(prodNo);
            // 如果是空则添加主调计划
            if (planModel == null) {
                ProdPla plan = new ProdPla();
                plan.setPropProdNo(order.getProdNo());
                plan.setPropProCod(order.getProdProCod());
                plan.setPropProdNum(order.getProdNum());
                plan.setPropCreDat(new Date());
                plan.setPropCreUid(ShiroUtils.getUserId());
                plan.setPropSta(1);
                plan.setPropIsDel((byte) 0);
                plan.setPropRem(order.getProdRem());
                plan.setPropIsSch((byte) 0);
                prodTaskMapper.insertProdPla(plan);
                for (int i = 0; i < prodPlaDetList.size(); i++) {
                    ProdPlaDet prodPlaDet = prodPlaDetList.get(i);
                    prodPlaDet.setPrpdPropId(plan.getPropId());
                    prodPlaDet.setPrpdIsNee((byte) 1);
                    prodPlaDet.setPrpdSta(1);
                    prodPlaDet.setPrpdIsReq((byte) 0);
                    prodPlaDet.setPrpdRetSta(1);
                    prodPlaDet.setPrpdIsDel((byte) 0);
                    prodTaskMapper.insertProdPlaDet(prodPlaDet);
                    //如果是生产完成状态则更新生产状态
                    if (prodPlaDet.getPrpdCod() != null && "p09".equals(prodPlaDet.getPrpdCod())) {
                        order.setProdExeSta(prodPlaDet.getPrpdRetSta().intValue());
                        prodTaskMapper.updateProdOrdProdExeStaByPrimaryKey(order);
                    }
                }
                logService.saveLog("普通任务池-->普通任务计划编辑", "新增计划号为：【" + plan.getPropProdNo() + "】的普通计划。");
            }
            // 如果是非空则更新主调计划
            else {
                // 执行删除计划
                for (int i = 0; i < delPrpdIdList.size(); i++) {
                    prodTaskMapper.deleteProdPlanDetailByPrimaryKey(delPrpdIdList.get(i));
                }
                List<ProdPlaDet> existProdPlaDetList =
                        prodTaskMapper.findProdPlanDetailListByProdPlanId(planModel.getPropId());
                // 如果是变更则记录变更记录
                logService.saveLog("普通任务池-->普通任务计划编辑", "修改计划号为：【" + planModel.getPropProdNo() + "】的普通计划。");
                for (int i = 0; i < prodPlaDetList.size(); i++) {
                    ProdPlaDet newProdPlaDet = prodPlaDetList.get(i);
                    ProdPlaDet toDataBaseProdPlaDet =
                            convertInsertProdPlanDetail(existProdPlaDetList, newProdPlaDet);
                    // 如果数据库中有则更新
                    if (toDataBaseProdPlaDet != null) {
                        prodTaskMapper.updateProdPlaDet(toDataBaseProdPlaDet);
                        if (newProdPlaDet.getPrpdCod() != null && "p09".equals(toDataBaseProdPlaDet.getPrpdCod())) {
                            if (toDataBaseProdPlaDet.getPrpdRetSta() != null) {
                                order.setProdExeSta(toDataBaseProdPlaDet.getPrpdRetSta().intValue());
                                prodTaskMapper.updateProdOrdProdExeStaByPrimaryKey(order);
                            }
                        }
                    }
                    // 没有则添加
                    else {
                        newProdPlaDet.setPrpdPropId(planModel.getPropId());
                        newProdPlaDet.setPrpdIsNee((byte) 1);
                        newProdPlaDet.setPrpdSta(1);
                        newProdPlaDet.setPrpdIsReq((byte) 0);
                        prodTaskMapper.insertProdPlaDet(newProdPlaDet);
                        if (newProdPlaDet.getPrpdCod() != null && "p09".equals(newProdPlaDet.getPrpdCod())) {
                            order.setProdExeSta(newProdPlaDet.getPrpdRetSta().intValue());
                            prodTaskMapper.updateProdOrdProdExeStaByPrimaryKey(order);
                        }
                    }
                }
            }
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("【保存其他类生产令排产异常】：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存失败！");
        }
        return jsonResult;
    }

    /**
     * ConvertInsertProdPlanDetail 转换成对应的对象
     *
     * @param
     * @return com.zw.mes.module.prodtaskmanager.entity.ProdPlaDet
     * @author 徐一贺
     * @date 2021/1/16 9:32
     */
    private ProdPlaDet convertInsertProdPlanDetail(List<ProdPlaDet> existProdPlaDetList, ProdPlaDet newProdPlaDet) {
        ProdPlaDet insertProdPlaDet = null;
        for (int j = 0; j < existProdPlaDetList.size(); j++) {
            ProdPlaDet existProdPlaDet = existProdPlaDetList.get(j);
            if (existProdPlaDet.getPrpdCod() != null && newProdPlaDet.getPrpdCod() != null && existProdPlaDet.getPrpdCod().equals(newProdPlaDet.getPrpdCod())) {
                insertProdPlaDet = new ProdPlaDet();
                insertProdPlaDet.setPrpdId(existProdPlaDet.getPrpdId());
                insertProdPlaDet.setPrpdPropId(existProdPlaDet.getPrpdPropId());
                insertProdPlaDet.setPrpdNam(newProdPlaDet.getPrpdNam());
                insertProdPlaDet.setPrpdCod(newProdPlaDet.getPrpdCod());
                insertProdPlaDet.setPrpdOrdNo(newProdPlaDet.getPrpdOrdNo());
                insertProdPlaDet.setPrpdPlaStaDat(newProdPlaDet.getPrpdPlaStaDat());
                insertProdPlaDet.setPrpdPlaEndDat(newProdPlaDet.getPrpdPlaEndDat());
                insertProdPlaDet.setPrpdDepId(newProdPlaDet.getPrpdDepId());
                insertProdPlaDet.setPrpdSta(existProdPlaDet.getPrpdSta());
                insertProdPlaDet.setPrpdIsNee(existProdPlaDet.getPrpdIsNee());
                insertProdPlaDet.setPrpdIsReq(existProdPlaDet.getPrpdIsReq());
                insertProdPlaDet.setPrpdRem(newProdPlaDet.getPrpdRem());
                insertProdPlaDet.setPrpdAssWorHours(newProdPlaDet.getPrpdAssWorHours());
                if (newProdPlaDet.getPrpdChaRea() != null && !"".equals(newProdPlaDet.getPrpdChaRea())) {
                    insertProdPlaDet.setPrpdChaRea(newProdPlaDet.getPrpdChaRea());
                }
            }
        }
        return insertProdPlaDet;
    }

    /**
     * @methodName: convertInsertProdPlanDetail2
     * @description: 对象转换2
     * @param: existProdPlaDetList
     * @param: newProdPlaDet
     * @return： com.zw.mes.module.prodtaskmanager.entity.ProdPlaDet
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/9 14:20
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    private ProdPlaDet convertInsertProdPlanDetail2(List<ProdPlaDet> existProdPlaDetList, ProdPlaDet newProdPlaDet) {
        ProdPlaDet insertProdPlaDet = null;
        for (int j = 0; j < existProdPlaDetList.size(); j++) {
            ProdPlaDet existProdPlaDet = existProdPlaDetList.get(j);
            if (newProdPlaDet.getPrpdId() != null && existProdPlaDet.getPrpdId().intValue() == newProdPlaDet.getPrpdId().intValue()) {
                insertProdPlaDet = new ProdPlaDet();
                insertProdPlaDet.setPrpdId(existProdPlaDet.getPrpdId());
                insertProdPlaDet.setPrpdPropId(existProdPlaDet.getPrpdPropId());
                insertProdPlaDet.setPrpdNam(newProdPlaDet.getPrpdNam());
                insertProdPlaDet.setPrpdCod(newProdPlaDet.getPrpdCod());
                insertProdPlaDet.setPrpdOrdNo(newProdPlaDet.getPrpdOrdNo());
                insertProdPlaDet.setPrpdPlaStaDat(newProdPlaDet.getPrpdPlaStaDat());
                insertProdPlaDet.setPrpdPlaEndDat(newProdPlaDet.getPrpdPlaEndDat());
                insertProdPlaDet.setPrpdDepId(newProdPlaDet.getPrpdDepId());
                insertProdPlaDet.setPrpdSta(existProdPlaDet.getPrpdSta());
                insertProdPlaDet.setPrpdIsNee(existProdPlaDet.getPrpdIsNee());
                insertProdPlaDet.setPrpdIsReq(existProdPlaDet.getPrpdIsReq());
                insertProdPlaDet.setPrpdRem(newProdPlaDet.getPrpdRem());
                insertProdPlaDet.setPrpdAssWorHours(newProdPlaDet.getPrpdAssWorHours());
                if (newProdPlaDet.getPrpdChaRea() != null && !"".equals(newProdPlaDet.getPrpdChaRea())) {
                    insertProdPlaDet.setPrpdChaRea(newProdPlaDet.getPrpdChaRea());
                }
            }
        }
        return insertProdPlaDet;
    }

    /**
     * schedulingLoadDesignInfo 根据生产令获取该项目设计完成时间
     *
     * @param prodNo 生产令
     * @return Map<String, Object>
     * @author 徐一贺
     * @date 2021/1/16 11:10
     */
    public Map<String, Object> schedulingLoadDesignInfo(String prodNo) {
        VwProject vwProject = prodTaskMapper.getVwProjectByProdNo(prodNo);
        Map<String, Object> data = new HashMap<>();
        if (vwProject.getDsnTime() != null) {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
            data.put("completeDate", formatter.format(vwProject.getDsnTime()));
        } else {
            data.put("completeDate", "");
        }
        return data;
    }

    /**
     * findProdPlanListByProdNo 根据生产令号获取生产计划信息
     *
     * @param prodNo 生产令号
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdPla>
     * @author 徐一贺
     * @date 2021/1/16 12:48
     */
    public List<ProdPlaDetModel> findProdPlanListByProdNo(String prodNo) {
        return prodTaskMapper.findProdPlanListByProdNo(prodNo);
    }

    /**
     * findProdTaskListByProdNo 根据生产令号获取生产任务信息
     *
     * @param prodNo 生产令号
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdTas>
     * @author 徐一贺
     * @date 2021/1/16 12:51
     */
    public List<ProdTas> findProdTaskListByProdNo(String prodNo) {
        return prodTaskMapper.findProdTaskListByProdNo(prodNo);
    }

    /**
     * findProdTaskTypeListByProdNo 根据生产令号获取生产任务类别信息
     *
     * @param prodNo 生产令
     * @return java.util.List<java.lang.String>
     * @author 徐一贺
     * @date 2021/1/16 13:30
     */
    public List<String> findProdTaskTypeListByProdNo(String prodNo) {
        List<BaseData> dictionaryDataList = prodTaskMapper.findProdTaskTypeListByProdNo(prodNo);
        List<String> result = new ArrayList<>();
        for (int i = 0; i < dictionaryDataList.size(); i++) {
            BaseData data = dictionaryDataList.get(i);
            String[] typeArray = data.getBadaVal().split(",");
            for (int j = 0; j < typeArray.length; j++) {
                if (!result.contains(typeArray[j])) {
                    result.add(typeArray[j]);
                }
            }
        }
        return result;
    }

    /**
     * findProdPlanRetInfoListByProdNo 根据生产令号获取生产计划反馈的信息
     *
     * @param prodNo 生产令号
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdTas>
     * @author 徐一贺
     * @date 2021/1/16 12:54
     */
    public List<ProdPlaRet> findProdPlanRetInfoListByProdNo(String prodNo) {
        return prodTaskMapper.findProdPlanRetInfoListByProdNo(prodNo);
    }

    /**
     * getProdPlaByPropProdNo 根据生产令编号获取总调计划对象
     *
     * @param prodNo 生产令编号
     * @return com.zw.mes.module.prodtaskmanager.entity.ProdPla
     * @author 徐一贺
     * @date 2021/1/26 16:23
     */
    public ProdPla getProdPlaByPropProdNo(String prodNo) {
        return prodTaskMapper.getProdPlaByPropProdNo(prodNo);
    }

    /**
     * findProdPlaDetListByPrpdPropId 根据总调计划主表ID获取从表数据
     *
     * @param propId 总调计划主表ID
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdPlaDet>
     * @author 徐一贺
     * @date 2021/1/26 16:53
     */
    public List<ProdPlaDet> findProdPlaDetListByPrpdPropId(Integer propId) {
        return prodTaskMapper.findProdPlaDetListByPrpdPropId(propId);
    }

    /**
     * schedulingSubmit 提交排产计划
     *
     * @param prodIdArr 生产令主键
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/27 8:44
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult schedulingSubmit(String[] prodIdArr) {
        JsonResult jsonResult = new JsonResult();
        try {
            String msg = "";
            for (int i = 0; i < prodIdArr.length; i++) {
                Integer prodId = Integer.valueOf(prodIdArr[i]);
                // 获取生产令对象
                ProdOrd prodOrd = prodTaskMapper.getProdOrdByPrimaryKey(prodId);
                // 获取总调计划主表对象
                ProdPla prodPla = prodTaskMapper.getProdPlaByPropProdNo(prodOrd.getProdNo());
                if (prodPla.getPropSta() == 1 || prodPla.getPropSta() == 4) {
                    prodPla.setPropSta(2);
                    prodPla.setPropCreDat(new Date());
                    prodPla.setPropCreUid(ShiroUtils.getUserId());
                    prodPla.setPropRejRea(null);
                    prodPla.setPropRejReaMin(null);
                    prodTaskMapper.updateProdPlaPropStaByPrimaryKey(prodPla);
                    prodTaskMapper.updateProdPlaPropCreDatAndPropCreUidByPrimaryKey(prodPla);
                    logService.saveLog("排产任务池-提交排产", "提交了生产令编号为：【" + prodOrd.getProdNo() + "】的总调计划！");
                    msg += "尊敬的用户，计划号为【" + prodOrd.getProdNo() + "】的总调计划提交成功！<BR>";
                } else if (prodPla.getPropSta() == 2) {
                    jsonResult.setType(JsonResult.ResultType.SUCCESS);
                    msg += "尊敬的用户，计划号为【" + prodOrd.getProdNo() + "】的总调计划已经提交，不必再次提交！";
                } else if (prodPla.getPropSta() == 3) {
                    jsonResult.setType(JsonResult.ResultType.SUCCESS);
                    msg += "尊敬的用户，计划号为【" + prodOrd.getProdNo() + "】的总调计划已经审核通过，不必再次提交！";
                }
            }
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("提交总调排产计划异常：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("提交总调排产计划失败！");
        }
        return jsonResult;
    }

    /**
     * findApplicantList 获取申请人列表：已提交未通过、未驳回计划提交人的姓名列表
     *
     * @return java.util.List<java.lang.String>
     * @author 徐一贺
     * @date 2021/1/27 9:15
     */
    public List<String> findApplicantList(String name) {
        return prodTaskMapper.findApplicantList(name);
    }

    /**
     * findAuditList 加载总调计划审核列表
     *
     * @param param 检索条件
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdPlaModel>
     * @author 徐一贺
     * @date 2021/1/27 9:56
     */
    public List<ProdPlaModel> findAuditList(ProdPlaModel param) {
        return prodTaskMapper.findAuditList(param);
    }

    /**
     * @methodName: loadMinisterialAuditList
     * @description: 加载部级审核列表
     * @param: param
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺
     * @date： 2021/3/23 16:06
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    public List<ProdPlaModel> loadMinisterialAuditList(ProdPlaModel param) {
        return prodTaskMapper.loadMinisterialAuditList(param);
    }

    /**
     * auditReject 驳回
     *
     * @param prodPlaModel 驳回的信息
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/27 11:18
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult auditReject(ProdPlaModel prodPlaModel) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPrimaryKey(prodPlaModel.getPropId());
            if (prodPla.getPropSta() == 2 || prodPla.getPropSta() == 6) {
                prodPlaModel.setPropSta(4);
                prodPlaModel.setPropAudDat(new Date());
                prodTaskMapper.updateProdPlaPropStaByPrimaryKey(prodPlaModel);
                logService.saveLog("总调计划审核-驳回", "驳回了生产令编号为：【" + prodPla.getPropProdNo() + "】的总调计划！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户，驳回总调计划成功！");
            } else if (prodPla.getPropSta() == 4) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("总调计划，此总调计划已经驳回，不必再次驳回！");
            } else if (prodPla.getPropSta() == 3) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("总调计划，此总调计划已经审批通过，不可驳回！");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户，驳回总调计划失败！");
        }
        return jsonResult;
    }

    /**
     * 驳回
     *
     * @param prodPlaModel
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult ministerialAuditReject(ProdPlaModel prodPlaModel) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPrimaryKey(prodPlaModel.getPropId());
            if (prodPla.getPropSta() == 3) {
                prodPlaModel.setPropSta(6);
                prodPlaModel.setPropMinAudDat(new Date());
                prodTaskMapper.updateProdPlaPropStaMinByPrimaryKey(prodPlaModel);
                logService.saveLog("总调计划审核-驳回", "驳回了生产令编号为：【" + prodPla.getPropProdNo() + "】的总调计划！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户，驳回总调计划成功！");
            } else if (prodPla.getPropSta() == 6) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("总调计划，此总调计划已经驳回，不必再次驳回！");
            } else if (prodPla.getPropSta() == 5) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("总调计划，此总调计划已经审批通过，不可驳回！");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户，驳回总调计划失败！");
        }
        return jsonResult;
    }

    /**
     * auditAgree 同意
     *
     * @param prodPlaModel
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/27 12:30
     */
    public JsonResult auditAgree(ProdPlaModel prodPlaModel) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPrimaryKey(prodPlaModel.getPropId());
            if (prodPla.getPropSta() == 2) {
                prodPlaModel.setPropSta(3);
                prodPlaModel.setPropRejRea(null);
                prodPlaModel.setPropAudDat(new Date());
                prodTaskMapper.updateProdPlaPropStaByPrimaryKey(prodPlaModel);
                ProdPlaCha prodPlaCha =
                        prodTaskMapper.getProdPlaChaByPrpcPropIdAndLast(prodPlaModel.getPropId());
                if (prodPlaCha != null) {
                    prodPlaCha.setProcStatus(1);
                }
                prodTaskMapper.updateProcStatusByPrimaryKey(prodPlaCha);
                logService.saveLog("总调计划审核", "审核通过了生产令编号为：【" + prodPla.getPropProdNo() + "】的总调计划！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户,您审核总调计划成功！");
            } else if (prodPla.getPropSta() == 3) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户,您审核总调计划已经审核通过，不必再次审核！");
            } else if (prodPla.getPropSta() == 4) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户,您审核总调计划已经驳回，不可再次审核同意！");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户,您审核总调计划失败！");
        }
        return jsonResult;
    }

    /**
     * @methodName: ministerialAuditAgree
     * @description: 审核通过
     * @param: prodPlaModel
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺
     * @date： 2021/3/23 16:40
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult ministerialAuditAgree(ProdPlaModel prodPlaModel) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPrimaryKey(prodPlaModel.getPropId());
            if (prodPla.getPropSta() == 3) {
                prodPlaModel.setPropSta(5);
                prodPlaModel.setPropRejRea(null);
                prodPlaModel.setPropRelDat(new Date());
                prodPlaModel.setPropMinAudDat(new Date());
                prodTaskMapper.updateProdPlaPropStaMinByPrimaryKey(prodPlaModel);
                ProdPlaCha prodPlaCha =
                        prodTaskMapper.getProdPlaChaByPrpcPropIdAndLast(prodPlaModel.getPropId());
                if (prodPlaCha != null) {
                    prodPlaCha.setProcStatus(1);
                    prodTaskMapper.updateProcStatusByPrimaryKey(prodPlaCha);
                }

                logService.saveLog("总调计划审核", "审核通过了生产令编号为：【" + prodPla.getPropProdNo() + "】的总调计划！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户,您审核总调计划成功！");
            } else if (prodPla.getPropSta() == 5) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户,您审核总调计划已经审核通过，不必再次审核！");
            } else if (prodPla.getPropSta() == 6) {
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户,您审核总调计划已经驳回，不可再次审核同意！");
            }

        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户,您审核总调计划失败！");
        }
        return jsonResult;
    }

    /**
     * findBasePlanList 总调计划基础信息维护列表
     *
     * @param
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.BaseData>
     * @author 徐一贺
     * @date 2021/1/27 14:44
     */
    public List<BaseData> findBasePlanList() {
        List<BaseData> list = prodTaskMapper.findBasePlanList();
        for (int i = 0; i < list.size(); i++) {
            String htmlElement = "";
            List<BaseData> retList =
                    prodTaskMapper.findBaseDataByBadaPidAndNotDel(list.get(i).getBadaId());
            for (int j = 0; j < retList.size(); j++) {
                htmlElement +=
                        "<li><a style=\"text-align:left;\" href=\"javaScript:void(0)\">"
                                + retList.get(j).getBadaNam()
                                + "</a><span class=\"pull-right\"><button onclick=\"removeRet("
                                + retList.get(j).getBadaId()
                                + ")\" type=\"button\" class=\"btn btn-danger btn-xs\">删除</button></span><span class=\"pull-right\"><button onclick=\"showEdit("
                                + retList.get(j).getBadaId()
                                + ")\" type=\"button\" class=\"btn btn-warning btn-xs\">编辑</button></span></li>";
            }
            if (htmlElement.length() > 0) {
                htmlElement = "<ul class=\"retList\" style=\"list-style:none;\">" + htmlElement + "</ul>";
                list.get(i).setChildHtml(htmlElement);
            }
        }
        return list;
    }

    /**
     * findBasePlanOnlyList 总调计划列表
     *
     * @param
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.BaseData>
     * @author 徐一贺
     * @date 2021/1/28 15:27
     */
    public List<BaseData> findBasePlanOnlyList() {
        List<BaseData> list = prodTaskMapper.findBasePlanList();
        return list;
    }

    /**
     * findPlanBadaTyp2List 跳转到计划信息管理页面
     *
     * @param
     * @return java.util.List<java.lang.String>
     * @author 徐一贺
     * @date 2021/1/27 14:55
     */
    public List<String> findPlanBadaTyp2List() {
        return prodTaskMapper.findPlanBadaTyp2List();
    }

    /**
     * baseAddPlan 添加计划信息
     *
     * @param baseData
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/27 15:06
     */
    public JsonResult baseAddPlan(BaseData baseData) {
        JsonResult jsonResult = new JsonResult();
        try {
            BaseData baseData1 = prodTaskMapper.getPlanBaseDataByNam(baseData);
            if (baseData1 != null) {
                jsonResult.setType(JsonResult.ResultType.ERROR);
                jsonResult.setMsg("尊敬的用户，您添加的计划已存在请修改计划名称后重新添加！");
                return jsonResult;
            } else {
                BaseData baseData2 = prodTaskMapper.getBaseDataForLast();
                String lastBadaCod = baseData2.getBadaCod();
                Integer badaCodNo = Integer.valueOf(lastBadaCod.substring(1)) + 1;
                baseData.setBadaCod("p" + badaCodNo);
                baseData.setBadaOrdNo(baseData2.getBadaOrdNo() + 1);
                baseData.setBadaTyp("总调计划");
                baseData.setBadaIsDel((byte) 0);
                baseData.setBadaVal("0");
                prodTaskMapper.insertBaseData(baseData);
                logService.saveLog(
                        "基础信息维护-总调计划信息配置-添加计划", "添加了计划名称为：【" + baseData.getBadaNam() + "】的总调计划信息！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户，添加计划成功！");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户，添加计划失败！");
        }
        return jsonResult;
    }

    /**
     * baseRemovePla 删除计划信息
     *
     * @param baseData
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/27 15:57
     */
    public JsonResult baseRemovePla(BaseData baseData) {
        JsonResult jsonResult = new JsonResult();
        try {
            BaseData baseData1 = prodTaskMapper.getBaseDataByPrimaryKey(baseData);
            Integer existPlaDetCou = prodTaskMapper.getExistPlaDetCouByPrpdCod(baseData1.getBadaCod());
            if (existPlaDetCou > 0) {
                jsonResult.setType(JsonResult.ResultType.ERROR);
                jsonResult.setMsg("尊敬的用户，您要删除的计划已经被排产不可删除！");
                return jsonResult;
            } else {
                prodTaskMapper.removeBaseData(baseData);
                logService.saveLog(
                        "基础信息维护-总调计划信息配置-删除计划", "删除了计划名称为：【" + baseData.getBadaNam() + "】的总调计划信息！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户，删除总调计划成功！");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户，删除总调计划失败！");
        }
        return jsonResult;
    }

    /**
     * baseRemoveRet 删除反馈信息
     *
     * @param baseData
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/28 11:25
     */
    public JsonResult baseRemoveRet(BaseData baseData) {
        JsonResult jsonResult = new JsonResult();
        try {
            BaseData ret = prodTaskMapper.getBaseDataByPrimaryKey(baseData);
            Integer existPlaDetCou = prodTaskMapper.getExistRetCouByPrpdCod(ret.getBadaCod());
            if (existPlaDetCou > 0) {
                jsonResult.setType(JsonResult.ResultType.ERROR);
                jsonResult.setMsg("尊敬的用户，您要删除的反馈信息已经被使用不可删除！");
                return jsonResult;
            } else {
                prodTaskMapper.removeBaseData(baseData);
                logService.saveLog(
                        "基础信息维护-反馈信息管理-删除反馈信息", "删除了反馈信息名称为：【" + baseData.getBadaNam() + "】的反馈信息！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户，删除反馈信息成功！");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("删除反馈信息异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户，删除反馈信息失败！");
        }
        return jsonResult;
    }

    /**
     * baseGetRetInf 根据主键获取反馈信息数据
     *
     * @param badaId 主键
     * @return com.zw.mes.module.prodtaskmanager.entity.BaseData
     * @author 徐一贺
     * @date 2021/1/28 10:28
     */
    public BaseData baseGetRetInf(Integer badaId) {
        BaseData condition = new BaseData();
        condition.setBadaId(badaId);
        return prodTaskMapper.getBaseDataByPrimaryKey(condition);
    }

    /**
     * baseAddOrEditRet 添加或编辑反馈信息
     *
     * @param baseData 反馈信息
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/28 10:59
     */
    public JsonResult baseAddOrEditRet(BaseData baseData) {
        JsonResult jsonResult = new JsonResult();
        try {
            if (baseData.getBadaId() == null) {
                BaseData existBaseData = prodTaskMapper.getRetBaseDataByNam(baseData);
                if (existBaseData != null) {
                    jsonResult.setType(JsonResult.ResultType.ERROR);
                    jsonResult.setMsg("尊敬的用户，您添加的反馈信息已存在，请修改反馈信息名称后重新添加！");
                    return jsonResult;
                } else {
                    BaseData lastRet = prodTaskMapper.getRetBaseDataForLast();
                    String lastBadaCod = lastRet.getBadaCod();
                    Integer badaCodNo = Integer.valueOf(lastBadaCod.substring(1)) + 1;
                    baseData.setBadaCod("r" + badaCodNo);
                    baseData.setBadaOrdNo(lastRet.getBadaOrdNo() + 1);
                    baseData.setBadaTyp("反馈节点");
                    baseData.setBadaIsDel((byte) 0);
                    BaseData parentPlanCondition = new BaseData();
                    parentPlanCondition.setBadaId(baseData.getBadaPid());
                    BaseData parentPlan = prodTaskMapper.getBaseDataByPrimaryKey(parentPlanCondition);
                    baseData.setBadaVal(parentPlan.getBadaTyp2());
                    prodTaskMapper.insertBaseData(baseData);
                    logService.saveLog(
                            "基础信息维护-反馈信息管理-添加反馈信息", "添加了反馈信息名称为：【" + baseData.getBadaNam() + "】的反馈信息！");
                    jsonResult.setType(JsonResult.ResultType.SUCCESS);
                    jsonResult.setMsg("尊敬的用户，添加反馈信息成功！");
                }
            } else {
                BaseData existBaseData = prodTaskMapper.getBaseDataByPrimaryKey(baseData);
                prodTaskMapper.updateBaseDataBadaNamByPrimaryKey(baseData);
                logService.saveLog(
                        "基础信息维护-反馈信息管理-修改反馈信息",
                        "修改前反馈信息名称为：【"
                                + existBaseData.getBadaNam()
                                + "】，修改后反馈信息名称为：【"
                                + baseData.getBadaNam()
                                + "】！");
                jsonResult.setType(JsonResult.ResultType.SUCCESS);
                jsonResult.setMsg("尊敬的用户，修改反馈信息成功！");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
            log.error("总调计划审核异常信息：" + ex.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("尊敬的用户，操作失败！");
        }
        return jsonResult;
    }

    /**
     * changeQueryList 获取变更查询列表
     *
     * @param param 查询条件
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/1/29 10:15
     */
    public List<ProdPlaCha> findChangeQueryList(ProdPlaCha param) {
        if (param.getPrpcCodText() != null && param.getPrpcCodText().length() > 0) {
            String[] prpcCods = param.getPrpcCodText().split(",");
            String prpcCodText = "";
            for (int i = 0; i < prpcCods.length; i++) {
                prpcCodText += "'" + prpcCods[i] + "',";
            }
            prpcCodText = prpcCodText.substring(0, prpcCodText.length() - 1);
            param.setPrpcCodText(prpcCodText);
        }
        return prodTaskMapper.findChangeQueryList(param);
    }

    /**
     * findCommonLoadPlanData 根据生产令编号获取计划数据
     *
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdPlaDetModel>
     * @author 徐一贺
     * @date 2021/1/30 9:04
     */
    public List<ProdPlaDet> findCommonLoadPlanTemplateData() {
        return prodTaskMapper.findCommonLoadPlanTemplateData();
    }

    /**
     * findCommonLoadExistPlanData 根据生产令号获取计划列表
     *
     * @param prodOrdNo 生产令编号
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdPlaDet>
     * @author 徐一贺
     * @date 2021/2/1 10:33
     */
    public List<ProdPlaDet> findCommonLoadExistPlanData(String prodOrdNo) {
        return prodTaskMapper.findCommonLoadExistPlanData(prodOrdNo);
    }

    /**
     * updateProdPlaPropIsSchByPropProdNo 根据生产令编号更新排产完成标识
     *
     * @param prodNo    生产令编号
     * @param propIsSch 是否排产完毕
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/2/1 13:04
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult updateProdPlaPropIsSchByPropProdNo(String prodNo, byte propIsSch) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPropProdNo(prodNo);
            prodPla.setPropIsSch(propIsSch);
            prodTaskMapper.updateProdPlaPropIsSchByPropProdNo(prodPla);
            logService.saveLog("普通任务池-普通任务计划编辑-排产完成", "生产令号为：【" + prodNo + "】的普通计划排产完成！");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("排产完成成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("普通任务池-普通任务计划编辑-排产完成异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("排产完成失败！");
        }
        return jsonResult;
    }

    /**
     * findFacPlaEdiAndRetList 根据搜索条件获取生产计划编辑与反馈页面的列表
     *
     * @param param 搜索条件
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdPlaDetModel>
     * @author 徐一贺
     * @date 2021/2/1 14:26
     */
    public List<ProdPlaDetModel> findFacPlaEdiAndRetList(ProdPlaDetModel param) {
        return prodTaskMapper.findFacPlaEdiAndRetList(param);
    }

    /**
     * saveEditRetSta 保存反馈编辑状态
     *
     * @param param 主键和反馈编辑状态
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/2/1 15:36
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveEditRetSta(ProdPlaDetModel param) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPrpdId(param.getPrpdId());
            ProdPlaDet prodPlaDet = prodTaskMapper.getProdPlaDetByPrimaryKey(param.getPrpdId());
            prodTaskMapper.updateProdPlaDetPrpdRetStaByPrimaryKey(param);
            String retSta = "";
            switch (param.getPrpdRetSta()) {
                case 1:
                    retSta = "未开始";
                    break;
                case 2:
                    retSta = "执行中";
                    break;
                case 3:
                    retSta = "已完成";
                    break;
                default:
                    break;
            }
            logService.saveLog(
                    "生产计划编辑与反馈-反馈编辑状态",
                    "生产令号为：【"
                            + prodPla.getPropProdNo()
                            + "】的普通计划【"
                            + prodPlaDet.getPrpdNam()
                            + "】的反馈状态编辑为【"
                            + retSta
                            + "】！");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存反馈编辑状态成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("生产计划编辑与反馈-反馈编辑状态-保存异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存反馈编辑状态失败！");
        }
        return jsonResult;
    }

    /**
     * factoryPlanEditAndReturnLoadProdList 加载审核通过的生产令列表
     *
     * @param
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdOrdModel>
     * @author 徐一贺
     * @date 2021/2/1 16:29
     */
    public List<ProdOrdModel> factoryPlanEditAndReturnLoadProdList() {
        return prodTaskMapper.findFactoryPlanEditAndReturnLoadProdList();
    }

    /**
     * facPlaEdiAndRetSave 保存生产计划编辑
     *
     * @param prodFacList 生产计划
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/2/2 11:17
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult facPlaEdiAndRetSave(List<ProdFac> prodFacList) {
        JsonResult jsonResult = new JsonResult();
        try {
            Date currentDate = new Date();
            for (int i = 0; i < prodFacList.size(); i++) {
                prodFacList.get(i).setProfFac(prodFacList.get(i).getProfFacWor());
                prodFacList.get(i).setProfCreUid(ShiroUtils.getUserId());
                prodFacList.get(i).setProfCreDat(currentDate);
                prodFacList.get(i).setProfIsDel((byte) 0);
                prodTaskMapper.insertProdFac(prodFacList.get(i));
            }
            logService.saveLog(
                    "生产计划编辑与反馈-保存生产计划", "生产令号为：【" + prodFacList.get(0).getProfProdNo() + "】的生产计划保存成功！");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存生产计划成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("生产计划编辑与反馈-保存生产计划异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存生产计划失败！");
        }
        return jsonResult;
    }

    /**
     * removeDevicesClass 删除设备类的二级计划
     *
     * @param id 主键
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/2/2 12:49
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult removeDevicesClass(Integer id) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdFac prodFac = prodTaskMapper.getProdFacByPrimaryKey(id);
            prodTaskMapper.removeDevicesClass(id);
            logService.saveLog(
                    "生产计划编辑与反馈-删除生产计划",
                    "生产令号为：【" + prodFac.getProfProdNo() + "】，工作内容为【" + prodFac.getProfName() + "】的生产计划删除成功！");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("删除生产计划成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("生产计划编辑与反馈-保存生产计划异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("删除生产计划失败！");
        }
        return jsonResult;
    }

    /**
     * removeOtherClass 删除其他类的一级计划
     *
     * @param id 主键
     * @return com.zw.mes.common.JsonResult
     * @author 徐一贺
     * @date 2021/2/2 13:08
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult removeOtherClass(Integer id) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPla prodPla = prodTaskMapper.getProdPlaByPrpdId(id);
            ProdPlaDet prodPlaDet = prodTaskMapper.getProdPlaDetByPrimaryKey(id);
            prodTaskMapper.removeOtherClass(id);
            logService.saveLog(
                    "生产计划编辑与反馈-删除生产计划",
                    "生产令号为：【"
                            + prodPla.getPropProdNo()
                            + "】，工作内容为【"
                            + prodPlaDet.getPrpdNam()
                            + "】的生产计划删除成功！");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("删除生产计划成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("生产计划编辑与反馈-保存生产计划异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("删除生产计划失败！");
        }
        return jsonResult;
    }

    /**
     * findProdOrdQueryList 根据条件查询生产进度看板列表
     *
     * @param param 检索条件
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.model.ProdOrderQueryModel>
     * @author 徐一贺
     * @date 2021/2/2 15:05
     */
    public List<ProdOrderQueryModel> findProdOrdQueryList(ProdOrderQueryModel param) {
        return prodTaskMapper.findProdOrdQueryList(param);
    }

    /**
     * getProdOrdByPropProdNo 根据生产令号获取生产令
     *
     * @param prodNo
     * @return com.zw.mes.module.prodtaskmanager.entity.ProdOrd
     * @author 徐一贺
     * @date 2021/2/3 15:37
     */
    public ProdOrdModel getProdOrdByPropProdNo(String prodNo) {
        return prodOrdMapper.getProdOrdByProdNo(prodNo);
    }

    /**
     * getProdFacListBy 根据生产令号获取厂级任务列表
     *
     * @param prodNo 生产令号
     * @return java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdTas>
     * @author 徐一贺
     * @date 2021/2/3 15:44
     */
    public List<ProdFac> findProdFacListBy(String prodNo) {
        return prodTaskMapper.findProdOrdByProdNo(prodNo);
    }

    /**
     * 根据项目编号获取项目信息
     *
     * @param proCode 项目编号
     * @return 项目信息
     */
    public VwProject getVwProjectByProCode(String proCode) {
        return prodOrdMapper.getVwProjectByProCode(proCode);
    }

    /**
     * 获取制作件清单主单列表
     *
     * @param param
     * @return
     */
    public List<VwDsnMakeResultModel> findProductionListViewList(VwDsnMakeResultModel param) {
        return prodOrdMapper.findProductionListViewList(param);
    }

    /**
     * 获取类型列表
     *
     * @param proCode 项目编号
     * @return
     */
    public List<String> getSpecialListByProCode(String proCode) {
        return prodOrdMapper.findSpecialListByProCode(proCode);
    }

    /**
     * 获取类型列表
     *
     * @param proCode 项目编号
     * @return
     */
    public List<String> getPurSpecialListByProCode(String proCode) {
        return prodOrdMapper.findPurSpecialListByProCode(proCode);
    }

    /**
     * 获取类型列表
     *
     * @param proCode 项目编号
     * @return
     */
    public List<String> getRawMatSpecialListByProCode(String proCode) {
        return prodOrdMapper.findRawMatSpecialListByProCode(proCode);
    }

    /**
     * 获取类型列表
     *
     * @param proCode 项目编号
     * @return
     */
    public List<String> getOutSpecialListByProCode(String proCode) {
        return prodOrdMapper.getOutSpecialListByProCode(proCode);
    }

    /**
     * 获取外购件主单列表
     *
     * @param param
     * @return
     */
    public List<VwRepResultModel> findPurPlanListViewList(VwRepResultModel param) {
        return prodOrdMapper.findPurPlanListViewList(param);
    }

    /**
     * 获取原材料主单列表
     *
     * @param param
     * @return
     */
    public List<VwRepResultModel> findRawMatPlanListViewList(VwRepResultModel param) {
        return prodOrdMapper.findRawMatPlanListViewList(param);
    }

    /**
     * 获取外协件主单列表
     *
     * @param param
     * @return
     */
    public List<VwRepResultModel> findOutPlanListViewList(VwRepResultModel param) {
        return prodOrdMapper.findOutPlanListViewList(param);
    }

    /**
     * 工艺卡的专业列表
     *
     * @param proCode
     * @return
     */
    public List<String> getProcessCardSpecialListByProCode(String proCode) {
        return prodOrdMapper.findProcessCardSpecialListByProCode(proCode);
    }

    /**
     * 获取工艺卡查看主单列表
     *
     * @param param
     * @return
     */
    public List<VwCraCardSheetModel> findProcessCardListViewList(VwCraCardSheetModel param) {
        return prodOrdMapper.findProcessCardListViewList(param);
    }

    /**
     * 获取工艺卡零件级列表
     *
     * @param param
     * @return
     */
    public List<VwCraCardSheetModel> findProcessPartsList(VwCraCardSheetModel param) {
        return prodOrdMapper.findProcessPartsList(param);
    }

    /**
     * 下料任务列表
     *
     * @param param
     * @return
     */
    public List<ProdCuttingDetailModel> cutTaskViewList(ProdCuttingDetailModel param) {
        return prodOrdMapper.cutTaskViewList(param);
    }

    /**
     * 装配派工单查看
     *
     * @param param
     * @return
     */
    public List<AsseAssemblySheetModel> findAssemblySheetListViewList(AsseAssemblySheetModel param) {
        return prodOrdMapper.findAssemblySheetListViewList(param);
    }

    /**
     * 根据条件获取总调计划查询列表
     *
     * @return
     */
    public List<PlanQueryModel> findPlanQueryList(PlanQueryModel param) {
        return prodTaskMapper.findPlanQueryList(param);
    }

    /**
     * 安装进度查看
     *
     * @param param
     * @return
     */
    public List<InstDispatchingListModel> findInstallListViewList(InstDispatchingListModel param) {
        return prodTaskMapper.findInstallListViewList(param);
    }

    /**
     * 获取装配进度查看列表
     *
     * @param param
     * @return
     */
    public List<AsseAssemblySheetRouteTransModel> findAssemblyListViewList(
            AsseAssemblySheetModel param) {
        return prodTaskMapper.findAssemblyListViewList(param);
    }

    /**
     * 获取部门列表
     *
     * @return
     */
    public List<SysDeptModel> findDeptList() {
        return prodTaskMapper.findDeptList();
    }

    /**
     * 根据主键获取部门对象信息
     *
     * @param deptId
     * @return
     */
    public SysDeptModel getSysDeptByPrimaryKey(Integer deptId) {
        return prodTaskMapper.getSysDeptByPrimaryKey(deptId);
    }

    /**
     * 根据生产令编号获取对应的厂级计划列表
     *
     * @param profProdNo
     * @return
     */
    public JsonResult getFactoryPlanEditAndReturnListByProfProdNo(String profProdNo) {
        JsonResult result = new JsonResult();
        try {
            List<ProdFac> prodFacList = prodTaskMapper.findProdFacByprofProdNo(profProdNo);
            for (ProdFac prodFac : prodFacList) {
                if (prodFac.getProfEndDat() != null && prodFac.getProfStaDat() != null) {
                    Long daysBetween =
                            (prodFac.getProfEndDat().getTime() - prodFac.getProfStaDat().getTime() + 1000000)
                                    / (60 * 60 * 24 * 1000);
                    prodFac.setDuration(daysBetween.intValue());
                } else {
                    prodFac.setDuration(null);
                }
                prodFac.setFlag("有数据");
            }
            FactoryPlanEditAndReturnListModel factoryPlanEditAndReturnListModel =
                    new FactoryPlanEditAndReturnListModel();
            ProdFac formData = new ProdFac();
            formData.setProfProdNo(profProdNo);
            factoryPlanEditAndReturnListModel.setFormData(formData);
            factoryPlanEditAndReturnListModel.setInsertData(prodFacList);
            result.setType(JsonResult.ResultType.SUCCESS);
            result.setData(factoryPlanEditAndReturnListModel);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("根据生产令编号获取对应的厂级计划列表异常:" + e.getMessage());
            result.setType(JsonResult.ResultType.ERROR);
            result.setMsg("获取失败！");
        }
        return result;
    }

    /**
     * 保存厂级计划编辑与反馈
     *
     * @param data
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveFactoryPlanEditAndReturnList(String data) {
        JsonResult result = new JsonResult();
        try {
            Date currentDate = new Date();
            Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
            ProdFac prodFac = gson.fromJson(data, ProdFac.class);
            String logContent = "";
            if (null == prodFac.getProfId()) {
                prodFac.setProfCreDat(currentDate);
                prodFac.setProfCreUid(ShiroUtils.getUserId());
                prodFac.setProfEdiDat(currentDate);
                prodFac.setProfEdiUid(ShiroUtils.getUserId());
                prodFac.setProfIsDel((byte) 0);
                prodTaskMapper.insertProdFac(prodFac);
                if (prodFac.getProfFac() != null && !"".equals(prodFac.getProfFac())) {
                    logContent += "分配车间/组/人员：【" + prodFac.getProfFac() + "】，";
                }
                if (prodFac.getProfName() != null && !"".equals(prodFac.getProfName())) {
                    logContent += "任务名称：【" + prodFac.getProfName() + "】，";
                }
                if (prodFac.getProfStaDat() != null) {
                    logContent += "开始时间：【" + prodFac.getProfStaDat() + "】，";
                }
                if (prodFac.getProfEndDat() != null) {
                    logContent += "结束时间：【" + prodFac.getProfEndDat() + "】，";
                }
                if (prodFac.getProfRem() != null && !"".equals(prodFac.getProfRem())) {
                    logContent += "备注：【" + prodFac.getProfRem() + "】，";
                }
                if (prodFac.getProfEdiDat() != null) {
                    logContent += "编辑时间：【" + prodFac.getProfEdiDat() + "】";
                }
                logService.saveLog(
                        "厂级计划编辑与反馈-新增计划",
                        "生产令编号为【" + prodFac.getProfProdNo() + "】新增了计划，计划内容是：" + logContent + "！");
            } else {
                ProdFac before = prodTaskMapper.getProdFacByPrimaryKey(prodFac.getProfId());
                if (before.getProfFac() != null
                        && !"".equals(before.getProfFac())
                        && prodFac.getProfFac() != null
                        && !"".equals(prodFac.getProfFac())
                        && !before.getProfFac().equals(prodFac.getProfFac())) {
                    logContent += "分配车间/组/人员：【" + before.getProfFac() + "】➠【" + prodFac.getProfFac() + "】，";
                } else if ((before.getProfFac() == null || "".equals(before.getProfFac()))
                        && (prodFac.getProfFac() != null && !"".equals(prodFac.getProfFac()))) {
                    logContent += "分配车间/组/人员：【】➠【" + prodFac.getProfFac() + "】，";
                } else if (before.getProfFac() != null
                        && !"".equals(before.getProfFac())
                        && (prodFac.getProfFac() == null || "".equals(prodFac.getProfFac()))) {
                    logContent += "分配车间/组/人员：【" + before.getProfFac() + "】➠【】，";
                }
                if (before.getProfName() != null
                        && !"".equals(before.getProfName())
                        && prodFac.getProfName() != null
                        && !"".equals(prodFac.getProfName())
                        && !before.getProfName().equals(prodFac.getProfName())) {
                    logContent += "任务名称：【" + before.getProfName() + "】➠【" + prodFac.getProfName() + "】，";
                } else if ((before.getProfName() == null || "".equals(before.getProfName()))
                        && (prodFac.getProfName() != null && !"".equals(prodFac.getProfName()))) {
                    logContent += "任务名称：【】➠【" + prodFac.getProfName() + "】，";
                } else if (before.getProfName() != null
                        && !"".equals(before.getProfName())
                        && (prodFac.getProfName() == null || "".equals(prodFac.getProfName()))) {
                    logContent += "任务名称：【" + before.getProfName() + "】➠【】，";
                }
                if (before.getProfStaDat() != null
                        && prodFac.getProfStaDat() != null
                        && !before.getProfStaDat().equals(prodFac.getProfStaDat())) {
                    logContent += "开始时间：【" + before.getProfStaDat() + "】➠【" + prodFac.getProfStaDat() + "】，";
                } else if (before.getProfStaDat() == null && prodFac.getProfStaDat() != null) {
                    logContent += "开始时间：【】➠【" + prodFac.getProfStaDat() + "】，";
                } else if (before.getProfStaDat() != null && prodFac.getProfStaDat() == null) {
                    logContent += "开始时间：【" + before.getProfStaDat() + "】➠【】，";
                }
                if (before.getProfEndDat() != null
                        && prodFac.getProfEndDat() != null
                        && !before.getProfEndDat().equals(prodFac.getProfEndDat())) {
                    logContent += "结束时间：【" + before.getProfEndDat() + "】➠【" + prodFac.getProfEndDat() + "】，";
                } else if (before.getProfEndDat() == null && prodFac.getProfEndDat() != null) {
                    logContent += "结束时间：【】➠【" + prodFac.getProfEndDat() + "】，";
                } else if (before.getProfEndDat() != null && prodFac.getProfEndDat() == null) {
                    logContent += "结束时间：【" + before.getProfEndDat() + "】➠【】，";
                }
                if (before.getProfRem() != null
                        && !"".equals(before.getProfRem())
                        && prodFac.getProfRem() != null
                        && !"".equals(prodFac.getProfRem())
                        && !before.getProfRem().equals(prodFac.getProfRem())) {
                    logContent += "备注：【" + before.getProfRem() + "】➠【" + prodFac.getProfRem() + "】，";
                } else if ((before.getProfRem() == null || "".equals(before.getProfRem()))
                        && (prodFac.getProfRem() != null && !"".equals(prodFac.getProfRem()))) {
                    logContent += "备注：【】➠【" + prodFac.getProfRem() + "】，";
                } else if (before.getProfRem() != null
                        && !"".equals(before.getProfRem())
                        && (prodFac.getProfRem() == null || "".equals(prodFac.getProfRem()))) {
                    logContent += "备注：【" + before.getProfRem() + "】➠【】，";
                }
                if (prodFac.getProfEdiDat() != null) {
                    logContent += "编辑时间：【" + prodFac.getProfEdiDat() + "】";
                }
                prodFac.setProfEdiDat(currentDate);
                prodFac.setProfEdiUid(ShiroUtils.getUserId());
                prodFac.setProfIsDel((byte) 0);
                logService.saveLog(
                        "厂级计划编辑与反馈-编辑计划",
                        "生产令编号为【" + prodFac.getProfProdNo() + "】编辑了计划，内容是" + logContent + "！");
                prodTaskMapper.updateProdFacBySave(prodFac);
            }
            result.setType(JsonResult.ResultType.SUCCESS);
            result.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("保存厂级计划编辑与反馈异常:" + e.getMessage());
            result.setType(JsonResult.ResultType.ERROR);
            result.setMsg("保存失败！");
        }
        return result;
    }

    /**
     * 删除厂级计划编辑与反馈
     *
     * @param profId
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult removeFactoryPlanEditAndReturnListByProfId(Integer profId) {
        JsonResult result = new JsonResult();
        try {
            ProdFac prodFac = prodTaskMapper.getProdFacByPrimaryKey(profId);
            prodFac.setProfIsDel((byte) 1);
            prodTaskMapper.updateProdFacProfIsDelByPrimaryKey(prodFac);
            String logContent = "";
            if (prodFac.getProfFac() != null && !"".equals(prodFac.getProfFac())) {
                logContent += "分配车间/组/人员：【" + prodFac.getProfFac() + "】，";
            }
            if (prodFac.getProfName() != null && !"".equals(prodFac.getProfName())) {
                logContent += "任务名称：【" + prodFac.getProfName() + "】，";
            }
            if (prodFac.getProfStaDat() != null) {
                logContent += "开始时间：【" + prodFac.getProfStaDat() + "】，";
            }
            if (prodFac.getProfEndDat() != null) {
                logContent += "结束时间：【" + prodFac.getProfEndDat() + "】，";
            }
            if (prodFac.getProfRem() != null && !"".equals(prodFac.getProfRem())) {
                logContent += "备注：【" + prodFac.getProfRem() + "】，";
            }
            if (prodFac.getProfEdiDat() != null) {
                logContent += "编辑时间：【" + prodFac.getProfEdiDat() + "】";
            }
            logService.saveLog(
                    "厂级计划编辑与反馈-删除计划", "生产令编号为【" + prodFac.getProfProdNo() + "】删除了计划，内容是" + logContent + "！");
            result.setType(JsonResult.ResultType.SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("保存厂级计划编辑与反馈异常:" + e.getMessage());
            result.setType(JsonResult.ResultType.ERROR);
            result.setMsg("删除失败！");
        }
        return result;
    }

    /**
     * 导出
     *
     * @param response
     * @param param
     */
    public void exportExcel(HttpServletResponse response, ProdOrderQueryModel param) {
        List<ProdOrderQueryModel> list = new ArrayList<>();
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        String path = uploadPath + user.getAccount() + "/";
        Subject userSubject = ShiroUtils.getSubject();
        // 1.创建临时内存表名
        String tempTableName =
                "##" + ShiroUtils.getUser().getAccount() + (UUID.randomUUID().toString().replace("-", ""));
        param.setTempTableName(tempTableName);
        // 2.查询出数据导入到临时表
        prodTaskMapper.createWarQueryTempTable(param);
        // 3.查询临时内存表数据导出
        Integer dataCount = prodTaskMapper.getTempTableDataCount(param);
        int step = 5000;
        FileUtils.mkdirs(path);
        // 方法1 如果写到同一个sheet
        path = path + "生产进度看板查询列表.xlsx";
        ExcelWriter excelWriter = null;
        try {
            // 这里 需要指定写用哪个class去写
            excelWriter = EasyExcel.write(path, ProdOrderQueryModel.class).build();
            // 这里注意 如果同一个sheet只要创建一次
            WriteSheet writeSheet = EasyExcel.writerSheet("sheet1").build();
            for (int topCount = 5000, notHaveTopCount = 0;
                 notHaveTopCount < dataCount;
                 notHaveTopCount += step) {
                param.setTopCount(topCount);
                param.setNotHaveTopCount(notHaveTopCount);
                list = prodTaskMapper.selectWarQueryTempTableByParam(param);
                if (list != null) {
                    excelWriter.write(list, writeSheet);
                }
            }
            // 4.删除临时内存表
            prodTaskMapper.dropWarQueryTempTable(tempTableName);
        } finally {
            // 千万别忘记finish 会帮忙关闭流
            if (excelWriter != null) {
                excelWriter.finish();
            }
        }
        // 5.下载
        FileUtils.downloadFile(path, response);
    }

    /**
     * @methodName: saveCommonPlanRet
     * @description: 保存普通计划反馈信息
     * @param: prodPlaDet
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺 tel:18941916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/3/26 9:28
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveCommonPlanRet(List<ProdPlaDet> prodPlaDetList) {
        JsonResult jsonResult = new JsonResult();

        try {
            Date currentDate = new Date();
            ProdPla prodPla = null;
            if (prodPlaDetList.size() > 0) {
                prodPla = prodTaskMapper.getProdPlaByPrimaryKey(prodPlaDetList.get(0).getPrpdPropId());
            }
            for (int i = 0; i < prodPlaDetList.size(); i++) {
                ProdPlaDet changeObj = prodPlaDetList.get(i);
                changeObj.setPrpdRetDate(currentDate);
                ProdPlaDet prodPlaDet = prodTaskMapper.getProdPlaDetByPrimaryKey(changeObj.getPrpdId());
                prodTaskMapper.updateProdPlaDetProdRetStaByPrimaryKey(changeObj);
                String statusStr = "";
                String statusClassStr = "";
                String beforeStatusStr = "";
                String beforeStatusClassStr = "";
                if (null == changeObj.getPrpdRetSta() || changeObj.getPrpdRetSta() == 1) {
                    statusStr = "未开始";
                    statusClassStr = "label-default";
                } else if (changeObj.getPrpdRetSta() == 2) {
                    statusStr = "执行中";
                    statusClassStr = "label-warning";
                } else if (changeObj.getPrpdRetSta() == 3) {
                    statusStr = "已完成";
                    statusClassStr = "label-success";
                }
                if (null == prodPlaDet.getPrpdRetSta() || prodPlaDet.getPrpdRetSta() == 1) {
                    beforeStatusStr = "未开始";
                    beforeStatusClassStr = "label-default";
                } else if (prodPlaDet.getPrpdRetSta() == 2) {
                    beforeStatusStr = "执行中";
                    beforeStatusClassStr = "label-warning";
                } else if (prodPlaDet.getPrpdRetSta() == 3) {
                    beforeStatusStr = "已完成";
                    beforeStatusClassStr = "label-success";
                }
                logService.saveLog(
                        "其他类项目计划反馈-保存",
                        "计划名称为【"
                                + prodPlaDet.getPrpdNam()
                                + "】的反馈状态由【<label class='badge "
                                + beforeStatusClassStr
                                + "'>"
                                + beforeStatusStr
                                + "</label>】修改成【<label class='badge "
                                + statusClassStr
                                + "'>"
                                + statusStr
                                + "</label>】。");
                if (prodPlaDet.getPrpdCod() != null && prodPlaDet.getPrpdCod().equals("p09") && prodPlaDet.getPrpdRetSta().intValue() == 3 && prodPla != null) {
                    ProdOrd prodOrd = new ProdOrd();
                    prodOrd.setProdNo(prodPla.getPropProdNo());
                    prodOrd.setProdExeSta(3);
                    prodTaskMapper.updateProdOrdProdExeStaByProdNo(prodOrd);
                }
            }
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存普通计划反馈信息成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("保存普通计划反馈信息异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存普通计划反馈信息失败！");
        }
        return jsonResult;
    }

    /**
     * @methodName: findTaskEditList
     * @description: 根据总调计划表主键获取要编辑的任务列表
     * @param: protPropId
     * @return： java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdTas>
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/6 10:24
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    public List<ProdTas> findTaskEditList(Integer protPropId) {
        return prodTaskMapper.findProdTasByProtPropId(protPropId);
    }

    /**
     * @methodName: returnEditList
     * @description: 根据总调计划表主键获取要编辑的反馈列表
     * @param: prprPropId
     * @return： java.util.List<com.zw.mes.module.prodtaskmanager.entity.ProdPlaRet>
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/6 10:34
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    public List<ProdPlaRet> returnEditList(Integer prprPropId) {
        return prodTaskMapper.findProdPlaRetByPrprPropId(prprPropId);
    }

    /**
     * @methodName: saveTaskSta
     * @description: 保存任务状态
     * @param: prodTas
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/6 12:48
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveTaskSta(ProdTas prodTas) {
        JsonResult jsonResult = new JsonResult();
        try {
            Date currentDate = new Date();
            ProdTas existProdTas = prodTaskMapper.getProdTasByPrimaryKey(prodTas.getProtId());
            if (existProdTas.getProtStaDat() == null) {
                prodTas.setProtStaDat(currentDate);
            } else {
                prodTas.setProtEndDat(currentDate);
            }
            prodTas.setProtDat(currentDate);
            prodTas.setProtUsrId(ShiroUtils.getUserId());
            prodTas.setProtDepId(ShiroUtils.getUser().getDeptId());
            prodTaskMapper.updateProdTasToChangetProtStaByPrimaryKey(prodTas);
            String beforeStaStr = "";
            if (existProdTas.getProtSta() == 1) {
                beforeStaStr = "未开始";
            } else if (existProdTas.getProtSta() == 2) {
                beforeStaStr = "执行中";
            } else if (existProdTas.getProtSta() == 3) {
                beforeStaStr = "已完成";
            }
            String afterStaStr = "";
            if (prodTas.getProtSta() == 1) {
                afterStaStr = "未开始";
            } else if (prodTas.getProtSta() == 2) {
                afterStaStr = "执行中";
            } else if (prodTas.getProtSta() == 3) {
                afterStaStr = "已完成";
            }
            logService.saveLog("任务状态与反馈编辑-保存任务状态", "任务名为【" + existProdTas.getProtNam() + "】的状态从【" + beforeStaStr + "】修改成了【" + afterStaStr + "】。");
            //获取生产
            ProdTas production = prodTaskMapper.getProdTasByProduction(existProdTas.getProtPropId());
            //如果是铆焊
            if ("t11".equals(existProdTas.getProtCod())) {
                //获取机加
                ProdTas machining = prodTaskMapper.getProdTasByMachining(existProdTas.getProtPropId());
                if (prodTas.getProtSta().intValue() == 2 || (prodTas.getProtSta().intValue() == 1 && machining.getProtSta().intValue() != 1)) {
                    production.setProtSta(2);
                } else if (prodTas.getProtSta().intValue() == 1 && machining.getProtSta().intValue() == 1) {
                    production.setProtSta(1);
                } else if (prodTas.getProtSta().intValue() == 3 && machining.getProtSta().intValue() == 3) {
                    production.setProtSta(3);
                }
                prodTaskMapper.updateProdTasProtstaByPrimaryKey(production);
            }
            //如果是机加
            else if ("t14".equals(existProdTas.getProtCod())) {
                //获取铆焊
                ProdTas rivetAndSolder = prodTaskMapper.getProdTasByRivetAndSolder(existProdTas.getProtPropId());
                if (prodTas.getProtSta().intValue() == 2 || (prodTas.getProtSta().intValue() == 1 && rivetAndSolder.getProtSta().intValue() != 1)) {
                    production.setProtSta(2);
                } else if (prodTas.getProtSta().intValue() == 1 && rivetAndSolder.getProtSta().intValue() == 1) {
                    production.setProtSta(1);
                } else if (prodTas.getProtSta().intValue() == 3 && rivetAndSolder.getProtSta().intValue() == 3) {
                    production.setProtSta(3);
                }
                prodTaskMapper.updateProdTasProtstaByPrimaryKey(production);
            }
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("保存任务状态异常:" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存失败！");
        }
        return jsonResult;
    }

    /**
     * @methodName: saveReturn
     * @description: 保存反馈时间
     * @param: prodTas
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/6 13:50
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveReturn(ProdPlaRet prodPlaRet) {
        JsonResult jsonResult = new JsonResult();
        try {
            ProdPlaRet existProdPlaRet = prodTaskMapper.getProdPlaRetByPrimaryKey(prodPlaRet.getPrprId());
            prodPlaRet.setPrprRetUsrId(ShiroUtils.getUserId());
            prodPlaRet.setPrprDepId(ShiroUtils.getUser().getDeptId());
            prodTaskMapper.updateProdPlaRetToChangetProtStaByPrimaryKey(prodPlaRet);
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            String beforeRetDatStr = "";
            if (existProdPlaRet.getPrprRetDat() == null) {
                beforeRetDatStr = "";
            } else {
                beforeRetDatStr = format.format(existProdPlaRet.getPrprRetDat());
            }
            String afterRetDatStr = "";
            if (prodPlaRet.getPrprRetDat() == null) {
                afterRetDatStr = "";
            } else {
                afterRetDatStr = format.format(prodPlaRet.getPrprRetDat());
            }
            logService.saveLog("任务状态与反馈编辑-保存反馈时间", "反馈名为【" + existProdPlaRet.getPrprNam() + "】的反馈时间从【" + beforeRetDatStr + "】修改成了【" + afterRetDatStr + "】。");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("保存反馈时间异常:" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存失败！");
        }
        return jsonResult;
    }

    /**
     * @methodName: getVwProStatusByProId
     * @description: 根据项目表主键获取项目状态
     * @param: proId
     * @return： com.zw.mes.module.prodtaskmanager.model.VwProStatus
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/6 15:13
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    public VwProStatus getVwProStatusByProId(Integer proId) {
        return prodTaskMapper.getVwProStatusByProId(proId);
    }

    /**
     * @methodName: getVwCraTaskDetailByProId
     * @description: 根据项目主键获取对应的状态信息数据
     * @param: proId
     * @return： com.zw.mes.module.prodtaskmanager.model.VwCraTaskDetail
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/6 15:57
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    public VwCraTaskDetail getVwCraTaskDetailByProId(Integer proId) {
        return prodTaskMapper.getVwCraTaskDetailByProId(proId);
    }

    /**
     * 根据项目主键获取项目状态表信息
     *
     * @param proId
     * @return
     */
    public VwProStatus selectProjectTask(Integer proId) {
        return prodTaskMapper.getVwProStatusByProId(proId);
    }

    /**
     * @methodName: saveTaskStatus
     * @description: 保存工艺和调试的任务状态
     * @param: param
     * @return： com.zw.mes.common.JsonResult
     * @exception：
     * @author： 徐一贺 tel:18341916590
     * @designer： 陈欣，盖世奇
     * @leader： 陈欣 tel:18104194240
     * @date： 2021/4/10 10:04
     * @office: 智能控制设计科
     * @research institute： 智能控制设计所
     * @department： 机械设计院
     * @company: 辽宁忠旺机械设备制造有限公司
     * @group： 忠旺集团
     * @version: 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public JsonResult saveTaskStatus(VwProStatus param) {
        JsonResult jsonResult = new JsonResult();
        try {
            VwProStatus vwProStatus = prodTaskMapper.getVwProStatusByProId(param.getProId());
            String beforeCraftIsNeedStr = "";
            if (vwProStatus.getCraftIsNeed() != null && vwProStatus.getCraftIsNeed() == 0) {
                beforeCraftIsNeedStr = "不需要";
            } else if (vwProStatus.getCraftIsNeed() == null || vwProStatus.getCraftIsNeed() == 1) {
                beforeCraftIsNeedStr = "需要";
            }
            String afterCraftIsNeedStr = "";
            if (param.getCraftIsNeed() != null && param.getCraftIsNeed() == 0) {
                afterCraftIsNeedStr = "不需要";
            } else if (param.getCraftIsNeed() == null || param.getCraftIsNeed() == 1) {
                afterCraftIsNeedStr = "需要";
            }
            String beforeDebuggingIsNeedStr = "";
            if (vwProStatus.getDebuggingIsNeed() != null && vwProStatus.getDebuggingIsNeed() == 0) {
                beforeDebuggingIsNeedStr = "不需要";
            } else if (vwProStatus.getDebuggingIsNeed() == null || vwProStatus.getDebuggingIsNeed() == 1) {
                beforeDebuggingIsNeedStr = "需要";
            }
            String afterDebuggingIsNeedStr = "";
            if (param.getDebuggingIsNeed() != null && param.getDebuggingIsNeed() == 0) {
                afterDebuggingIsNeedStr = "不需要";
            } else if (param.getDebuggingIsNeed() == null || param.getDebuggingIsNeed() == 1) {
                afterDebuggingIsNeedStr = "需要";
            }
            prodTaskMapper.updateProStatusTecAnDebugByProIdAndProCode(param);
            logService.saveLog("保存工艺和调试的任务状态", "项目编号为【" + param.getProCode() + "】的工艺状态从【" + beforeCraftIsNeedStr + "】修改成【" + afterCraftIsNeedStr + "】，调试状态从【" + beforeDebuggingIsNeedStr + "】修改成【" + afterDebuggingIsNeedStr + "】。");
            jsonResult.setType(JsonResult.ResultType.SUCCESS);
            jsonResult.setMsg("保存成功！");
        } catch (Exception e) {
            e.printStackTrace();
            log.error("保存工艺和调试的任务状态异常：" + e.getMessage());
            jsonResult.setType(JsonResult.ResultType.ERROR);
            jsonResult.setMsg("保存失败！");
        }
        return jsonResult;
    }
}
